package com.victor.core.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @Author: Victor
 * @Description:redis客户端
 * @Date:Create in 18:08 2018/4/10
 * @Modified By:
 */
@Component("redisClient")
public class RedisClient {
    @Autowired
    private JedisPool jedisPool;

    /**
     * @Auther:Victor
     * @Description:设置值
     * @Date:Create in 18:24 2018/4/10
     * @Modified By:
     */
    public void set(String key, String value) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.set(key, value);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:获取值
     * @Date:Create in 18:23 2018/4/10
     * @Modified By:
     */
    public String get(String key) throws Exception {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.get(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:获取剩余超时时间
     * @Date:Create in 18:23 2018/4/10
     * @Modified By:
     */
    public Long ttl(String key) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.ttl(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:设置超时时间
     * @Date:Create in 18:23 2018/4/10
     * @Modified By:
     */
    public void expire(String key, Integer time) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.expire(key, time);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:删除
     * @Date:Create in 18:24 2018/4/10
     * @Modified By:
     */
    public void del(String key) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.del(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description: SADD key member [member ...]
     * 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
     * 假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
     * 当 key 不是集合类型时，返回一个错误。
     * @Date:Create in 9:29 2018/4/13
     * @Modified By:
     */
    public void sadd(String key, String... value) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.sadd(key, value);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:SCARD key
     * 返回集合 key 的基数(集合中元素的数量)。
     * @Date:Create in 9:31 2018/4/13
     * @Modified By:
     */
    public long scard(String key) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.scard(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description: 正则表达式获取 key集合
     * @Date:Create in 15:43 2018/4/19
     * @Modified By:
     */
    public Set<String> keys(String pattern) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.keys(pattern);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:加上指定的增量值之后， key 的值。
     * @Date:Create in 8:49 2018/5/7
     * @Modified By:
     */
    public Long incrBy(String key, long integer) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.incrBy(key, integer);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:递增
     * @Date:Create in 8:49 2018/5/7
     * @Modified By:
     */
    public Long incr(String key) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.incr(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:递减
     * @Date:Create in 8:49 2018/5/7
     * @Modified By:
     */
    public Long decr(String key) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.decr(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:减去指定的增量值之后， key 的值。
     * @Date:Create in 8:49 2018/5/7
     * @Modified By:
     */
    public Long decrBy(String key, long integer) throws Exception {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.decrBy(key, integer);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:通过索引区间返回有序集合成指定区间内的成员 start 0 end -1 所有
     * @Date:Create in 8:59 2018/6/22
     * @Modified By:
     */
    public Set<String> zrange(String key, long start, long end) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.zrange(key, start, end);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @Auther:Victor
     * @Description:移除有序集合中给定的排名区间的所有成员 start 0 end -1 所有
     * @Date:Create in 8:56 2018/6/22
     * @Modified By:
     */
    public long zremrangeByRank(String key, long start, long end) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.zremrangeByRank(key, start, end);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 如果字段是哈希表中的一个新建字段，并且值设置成功，返回 1 。 如果哈希表中域字段已经存在且旧值已被新值覆盖，返回 0 。
     * @Auther:Victor
     * @Description:将哈希表 key 中的字段 field 的值设为 value 。
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public long hset(String key, String field, String value) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hset(key, field, value);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 设置成功，返回 1 。 如果给定字段已经存在且没有操作被执行，返回 0 。
     * @Auther:Victor
     * @Description:只有在字段 field 不存在时，设置哈希表字段的值。
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public long hsetnx(String key, String field, String value) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hsetnx(key, field, value);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }


    /**
     * @return 返回给定字段的值。如果给定的字段或 key 不存在时，返回 nil 。
     * @Auther:Victor
     * @Description: 获取存储在哈希表中指定字段的值
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public String hget(String key, String field) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hget(key, field);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 如果哈希表含有给定字段，返回 1 。 如果哈希表不含有给定字段，或 key 不存在，返回 0 。
     * @Auther:Victor
     * @Description: 查看哈希表 key 中，指定的字段是否存在。
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public boolean hexists(String key, String field) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hexists(key, field);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 被成功删除字段的数量，不包括被忽略的字段。
     * @Auther:Victor
     * @Description: 删除一个或多个哈希表字段
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public long hdel(String key, String... fields) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hdel(key, fields);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 执行 HINCRBY 命令之后，哈希表中字段的值。
     * @Auther:Victor
     * @Description:获取在哈希表中指定 key 的所有字段和值
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public Map<String, String> hgetall(String key) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hgetAll(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 执行 HINCRBY 命令之后，哈希表中字段的值。
     * @Auther:Victor
     * @Description:为哈希表 key 中的指定字段的整数值加上增量 increment
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public long hincrby(String key, String field, long value) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hincrBy(key, field, value);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 执行 Hincrbyfloat 命令之后，哈希表中字段的值。
     * @Auther:Victor
     * @Description:为哈希表 key 中的指定字段的浮点数值加上增量 increment
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public double hincrByFloat(String key, String field, double value) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hincrByFloat(key, field, value);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 包含哈希表中所有字段的列表。 当 key 不存在时，返回一个空列表。
     * @Auther:Victor
     * @Description:获取所有哈希表中的字段
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public Set<String> hkeys(String key) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hkeys(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 一个包含哈希表中所有值的表。 当 key 不存在时，返回一个空表。
     * @Auther:Victor
     * @Description:获取哈希表中所有值
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public List<String> hvals(String key) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hvals(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }


    /**
     * @return 哈希表中字段的数量。 当 key 不存在时，返回 0 。
     * @Auther:Victor
     * @Description:获取哈希表中字段的数量
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public long hlen(String key) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hlen(key);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }


    /**
     * @return 一个包含多个给定字段关联值的表，表值的排列顺序和指定字段的请求顺序一样。
     * @Auther:Victor
     * @Description:获取所有给定字段的值 如果指定的字段不存在于哈希表，那么返回一个 nil 值。
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public List<String> hmget(String key, String... fields) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hmget(key, fields);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }

    /**
     * @return 如果命令执行成功，返回 OK 。
     * @Auther:Victor
     * @Description:同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的字段。
     * @Date:Create in 9:06 2018/6/22
     * @Modified By:
     */
    public String hmset(String key, Map<String, String> hash) {

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hmset(key, hash);
        } finally {
            //返还到连接池
            jedis.close();
        }
    }
}
